#!/usr/bin/env node

const { exec } = require('child_process');
const path = require('path');

console.log('🛑 正在停止数据监控服务器...\n');

function getCurrentDirectoryPath() {
    return path.resolve(__dirname, '..');
}

function stopStockServer() {
    const projectPath = getCurrentDirectoryPath();

    // 更精确的方法：查找包含当前项目路径的server.js进程
    if (process.platform === 'win32') {
        const cmd = `wmic process where "commandline like '%${projectPath}%server.js%'" get processid,commandline /format:list`;

        exec(cmd, (error, stdout, stderr) => {
            if (!error && stdout) {
                const lines = stdout.split('\n');
                let foundProcesses = false;

                lines.forEach(line => {
                    if (line.includes('ProcessId=') && line.includes('server.js')) {
                        foundProcesses = true;
                        const pid = line.split('=')[1].trim();
                        if (pid && !isNaN(pid)) {
                            console.log(`📋 发现数据监控服务器进程 PID: ${pid}`);
                            exec(`taskkill /f /pid ${pid}`, (killError) => {
                                if (!killError) {
                                    console.log(`✅ 数据监控服务器进程 ${pid} 已停止`);
                                } else {
                                    console.log(`❌ 停止进程 ${pid} 失败: ${killError.message}`);
                                }
                            });
                        }
                    }
                });

                if (!foundProcesses) {
                    console.log('📋 未发现运行中的数据监控服务器');
                }
            } else {
                console.log('📋 未发现运行中的数据监控服务器');
            }

            // 等待2秒后检查端口3000
            setTimeout(() => {
                checkAndStopPort3000();
            }, 2000);
        });
    } else {
        // Linux/Mac
        exec(`ps aux | grep "${projectPath}/server.js" | grep -v grep`, (error, stdout, stderr) => {
            if (!error && stdout) {
                const lines = stdout.trim().split('\n');
                if (lines.length > 0 && lines[0]) {
                    const parts = lines[0].trim().split(/\s+/);
                    if (parts.length > 1) {
                        const pid = parts[1];
                        console.log(`📋 发现数据监控服务器进程 PID: ${pid}`);
                        exec(`kill -9 ${pid}`, (killError) => {
                            if (!killError) {
                                console.log(`✅ 数据监控服务器进程 ${pid} 已停止`);
                            } else {
                                console.log(`❌ 停止进程 ${pid} 失败`);
                            }
                        });
                    }
                } else {
                    console.log('📋 未发现运行中的数据监控服务器');
                }
            } else {
                console.log('📋 未发现运行中的数据监控服务器');
            }

            setTimeout(() => {
                checkAndStopPort3000();
            }, 2000);
        });
    }
}

function checkAndStopPort3000() {
    console.log('\n🔍 检查端口3000使用情况...');

    if (process.platform === 'win32') {
        exec('netstat -ano | findstr :3000', (error, stdout, stderr) => {
            if (!error && stdout) {
                const lines = stdout.trim().split('\n');
                let portInUse = false;

                lines.forEach(line => {
                    if (line.includes('LISTENING') || line.includes('ESTABLISHED')) {
                        const parts = line.trim().split(/\s+/);
                        if (parts.length > 4) {
                            const pid = parts[parts.length - 1];
                            if (pid && pid !== '0') {
                                portInUse = true;
                                console.log(`📋 端口3000被进程 ${pid} 占用`);

                                // 检查这个进程是否是我们的服务器
                                exec(`wmic process where "processid=${pid}" get commandline /format:list`, (cmdError, cmdStdout) => {
                                    if (!cmdError && cmdStdout && cmdStdout.includes('server.js')) {
                                        console.log(`🛑 停止占用端口3000的服务器进程 ${pid}`);
                                        exec(`taskkill /f /pid ${pid}`, (killError) => {
                                            if (!killError) {
                                                console.log(`✅ 端口3000进程 ${pid} 已停止`);
                                            } else {
                                                console.log(`❌ 停止端口3000进程 ${pid} 失败`);
                                            }
                                        });
                                    } else {
                                        console.log(`⚠️  进程 ${pid} 占用端口3000但不是数据监控服务器`);
                                    }
                                });
                            }
                        }
                    }
                });

                if (!portInUse) {
                    console.log('✅ 端口3000未被占用');
                }
            } else {
                console.log('✅ 端口3000未被占用');
            }

            finishUp();
        });
    } else {
        exec('lsof -ti:3000', (error, stdout, stderr) => {
            if (!error && stdout) {
                const pids = stdout.trim().split('\n');
                pids.forEach(pid => {
                    if (pid) {
                        console.log(`📋 端口3000被进程 ${pid} 占用`);
                        exec(`kill -9 ${pid}`, (killError) => {
                            if (!killError) {
                                console.log(`✅ 端口3000进程 ${pid} 已停止`);
                            } else {
                                console.log(`❌ 停止端口3000进程 ${pid} 失败`);
                            }
                        });
                    }
                });
            } else {
                console.log('✅ 端口3000未被占用');
            }

            finishUp();
        });
    }
}

function finishUp() {
    setTimeout(() => {
        console.log('\n🎉 数据监控服务器停止操作完成！');
        console.log('💡 端口3000已释放，可以重新启动服务器');
        process.exit(0);
    }, 1000);
}

stopStockServer();